/**
 * 脚本内是抖音的一些操作，如滑动视频
 * 
 * 1、下一个视频
 * 2、关闭全部弹窗
 * 
 * 
 * 点击一些按钮：1、首页。2、推荐。3、关注。
 * 
*/

/**
 * 基础的函数库
 */
let BSCRIPT = require('../Script_Base/Script_Base.js');
let S_GETINFO = require('./Script_GetInfo.js');

let {SERVER_BASE_ADDR, SERVER_BASE_ADDR_WS, EnumSysConf, LoadAllVariable, SetState, GetState, } = require('../Script_Base/Script_Base.js');
const { GetLiveRoomAthorName } = require('./Script_GetInfo.js');

let script_long_time = 1000 * 60 * 60;

let EnumSlfConf = {
    b_isCanRunningScript: true,          // true 可以运行脚本

    ra: null,                            // root
    isNeedRoot: false,                   // true 需要root函数
    // win_h: 1080,                         // 窗口的高度
    // win_w: 640,                          // 窗口的宽度
    b_isOutSleepWhile: false,            // true 退出睡眠函数
    b_isCanRunScrollVideo: true,         // true 可以运行刷视频任务
    b_isCanRunScrollLiveRoom: true,      // true 可以运行刷直播间任务
    str_AthorName: '',                   // 这个视频作者的名字
    t_longTimeCheckPage: new Date(),     // 上次检测界面的时间
    d_have_look_no: 0,                   // 已经看了多少视频
    d_start_look_time: new Date(),       // 开始看视频的时间
    str_LiveRoomAthorName: '',           // 直播间作者的名字
    t_start_inThis_LiveRoom: new Date(), // 进入这个直播间的时间
    d_inLiveRoom_randomTime: 0,          // 在直播间里停留的随机时间
}

/**
 * 停止全部的脚本
 */
function StopAllScript() {
    EnumSlfConf.b_isCanRunningScript = false;
}

/**
 * 自己写的需要休眠的时间。在休眠的过程中可以关闭弹出来的窗口。
 * @param {int} s_time 需要休眠的时间，单位秒
 */
function sleep_s(s_time) {
    let nowTime = new Date();
    while (new Date() - nowTime < s_time * 1000 && EnumSlfConf.b_isCanRunningScript) {
        ClosePage();
        sleep(900);
    }
}

/**
 * 设置是否可以运行自动刷抖音
 * @param {bolen} b True 可以运行自动刷抖音视频
*/

/**
 * 通过伏羲X打开 抖音
 */
function OpenDy() {
    console.log("通过伏羲X打开 抖音");
    BSCRIPT.OpenAppInFX("抖音", "com.ss.android.ugc.aweme:id/");
}

/**
 * 下一个视频
 */
function NextLive(win_w, win_h){
    console.log("ing NextLive,开始滑动");

    BSCRIPT.swipe_s((win_w / 4 * 3) + random(3, 8), (win_h / 5 * 3) + random(3, 8), (win_w / 4 * 3) + random(3, 8), (win_h / 10) + random(3, 8), random(300, 500));

    console.log("下一个视频");
}

/**
 * 进入作者的个人页面
 */
function InToAthorPage(win_w, win_h){
    console.log("开始 InToAthorPage");

    // 判断是不是正常的页面，如果不是的话就下一个视频
    while (S_GETINFO.CheckPage(new Date()) != 2001) {
        BSCRIPT.swipe_s((win_w / 4 * 3) + random(3, 8), (win_h / 5 * 3) + random(3, 8), (win_w / 10 * 1) + random(3, 8), (win_h / 5 * 3) + random(3, 8), random(400, 800));
        sleep_s(3);
    }

    console.log("进入作者的个人页面");
}

/**
 * 关闭全部的弹窗
 * @returns 
 */
function ClosePage() {
    if (selector().idStartsWith("com.ss.android.ugc.aweme:id/").exists()) {
        let node_btn_dd = selector().text('等待').findOnce();
        if (node_btn_dd) {
            // node_btn_dd.click();
            let node_btn_qd = selector().text('确定').findOnce();
            if (node_btn_qd) {
                console.log("关闭弹窗 等待");
            }else {
                console.log("关闭弹窗 等待 error");
            }
            sleep(1000);
            return;
        }

        let node_btn_YHZS = selector().text('以后再说').clickable(true).findOnce();
        if (node_btn_YHZS) {
            node_btn_YHZS.click();
            console.log("关闭弹窗 以后再说");
            sleep(1000);
            return;
        }

        let node_btn_WZDL = selector().text('我知道了').findOnce();
        if (node_btn_WZDL) {
            node_btn_WZDL.click();
            console.log("关闭弹窗 我知道了");
            sleep(1000);
            return;
        }

        let node_btn_QX = selector().text('取消').findOnce();
        if (node_btn_QX) {
            node_btn_QX.click();
            console.log("关闭弹窗 取消按钮");
            sleep(1000);
            return;
        }

        let node_btn_QD = selector().text('确定').findOnce();
        if (node_btn_QD) {
            node_btn_QD.click();
            console.log("关闭弹窗 确定按钮");
            sleep(1000);
            return;
        }        
    } else {
        console.log("不在抖音界面中");
        
        let node_btn_dd = selector().text('等待').findOnce();
        if (node_btn_dd) {
            // node_btn_dd.click();
            let node_btn_qd = selector().text('确定').findOnce();
            if (node_btn_qd) {
                console.log("关闭弹窗 等待");
            }else {
                console.log("关闭弹窗 等待 error");
            }
            
            sleep(1000);
            return;
        }

        /**
         * TODO：还有关闭系统自动更新
         */
    }
}


/**
 * 点击首页按钮
 * 
 * 首页的上4层可以点击
 */
function ClickIndexSY() {
    // console.log( selector().desc("首页，按钮").text("首页").findOne(5000).parent().parent().parent().parent().click());

    let btn_sy = selector().desc("首页，按钮").text("首页")
    if (btn_sy.exists()) {
        console.log("点击首页的首页按钮，结果为：", btn_sy.findOne(5000).parent().parent().parent().parent().click());
        return true;
    }else{
        console.log("没有找到首页按钮");
        return false;
    }    
}

/**
 * 点击首页的推荐按钮
 * 
 * desc:已选中，推荐，按钮
 * 
 * desc:购物，按钮 
 * desc:关注，按钮 
 * desc:直播，按钮 
 * desc:探索，按钮
 */
function ClickIndexTJ() {
    let btn_tj = selector().descEndsWith("推荐，按钮");
    if (btn_tj.exists()) {
        console.log("点击首页的推荐按钮，结果为：", btn_tj.findOne(5000).click());
        sleep_s(2);
        btn_tj = selector().descEndsWith("推荐，按钮");
        if (btn_tj.exists()) {
            console.log("第二次点击首页的推荐按钮，结果为：", btn_tj.findOne(5000).click());
        }
        return true;
    }else{
        console.log("没有找到推荐按钮");
        return false;
    }
    
}


function ClickIndexGZ() {
    let btn_gz = selector().descEndsWith("关注，按钮");
    if (btn_gz.exists()) {
        console.log("点击首页的关注按钮，结果为：", btn_gz.findOne(5000).click());
        sleep_s(2);
        btn_gz = selector().descEndsWith("关注，按钮");
        if (btn_gz.exists()) {
            console.log("第二次点击首页的关注按钮，结果为：", btn_gz.findOne(5000).click());
            sleep_s(2);  
        }
        // NextLive(EnumSysConf.win_w, EnumSysConf.win_h);
        // sleep_s(3);
        return true;
    }else{
        console.log("没有找到关注按钮");
        return false;
    }
}


/**
 * 给视频点赞
 * @returns 
 */
function FavourVideo() {
    let AthorName = selector().descStartsWith("未点赞").clickable().find();
    if (AthorName.empty()) {
        
    }else {
        for (let index = 0; index < AthorName.size(); index++) {
            var tv = AthorName.get(index);
            rect_screen = tv.bounds()
            if (rect_screen.top < EnumSysConf.win_h && rect_screen.top > EnumSysConf.win_h/4) {
                // console.log("是正确的点赞");
                
                tv.click();
                break;
            }else{
                // console.log("不是正确的点赞");
            }
        }
    }
}

/**
 * 随机出一个新的模式
 * @param {int} nowModel 现在的模式
 * @param {int} maxModel 最大的模式数量
 * @param {int} oldModel 上次的模式
 */
function NextModel(nowModel, maxModel, oldModel) {
    let nextModel = nowModel;
    while (nextModel == nowModel || nextModel == oldModel) {
        nextModel = random(1, maxModel);
    }
    return nextModel;
}

/**
 * 自动养号
 */
function BringUpAcc() {
    LoadAllVariable();
    SetState("开始自动养号脚本");

/**
 * 2刷视频-刷视频的时长随机，可以在3秒到1分半之间随机需要在推荐页和关注页切换刷 《比如刷十几分钟推荐页在刷十几分钟的关注页，切换的时间不要固定，设定5分钟到20分钟随机》
 * 3 随机进入主页刷视频，随机刷1-6个视频之后，退出2次 回到抖音主页然后继续重复步骤2和步骤3 《随机进入一个人的主页刷1-6个随机视频之后返回主页，间隔5-20分钟之间随机进入下一个人的主页》
 * 4 在刷推荐页和关注页的时候 如果刷到直播间可以随机进入直播间观看直播观看时长随机3-30分钟之间。
 * 5 保留之前刷到指定作者之后观看视频时长2分钟-4分钟随机。
 */

    let i_count = 0;    // 看了多少个视频
    let b_isFirst = true;
    let start_time = new Date();    // 开始看视频的时间

    let random_favour = random(10, 20);    // 每10至20个视频点赞一次
    let i_rf = 0;               // 随机点赞的计数器

    EnumSlfConf.b_isCanRunningScript = true;
    /**
     * 1、检测软件是否打开，如果没有打开就重新打开软件
     * 2、
     */

    /**
     * 当前要运行的模式
     * 0：出现错误的模式
     * 1：刷推荐视频模式
     * 2：刷关注页模式
     * 3：刷直播模式
     * 4：刷个人主页模式
     */
    let model_now = random(1, 4);
    let model_old = 0;

    let count_tj = 0;            // 已经刷推荐的数量
    let count_gz = 0;            // 已经刷关注的数量
    let count_zb = 0;            // 已经刷直播的数量
    let count_grzy = 0;          // 已经刷个人主页的数量

    let t_in_tj = random(EnumSysConf.t_in_tj_min, EnumSysConf.t_in_tj_max);        // 准备转入到推荐页的时间
    let t_in_gz = random(EnumSysConf.t_in_gz_min, EnumSysConf.t_in_gz_max);        // 准备转入到关注页的时间
    let t_in_zb = random(EnumSysConf.t_in_zb_min, EnumSysConf.t_in_zb_max)/1000;        // 准备转入到直播界面的时间
    let t_in_grzy = new Date();      // 准备转入到个人主页的时间
    let int_in_grzy = random(EnumSysConf.int_in_grzy_min, EnumSysConf.int_in_grzy_max);             // 刷个人主页随机数量
    let int_have_grzy = 0;                      // 已经刷了多少个个人主页的视频
    let name_grzy = "";                         // 个人主页的名字

    let t_start = new Date();       // 开始运行的时间
    let t_model_start = new Date();       // 开始运行的时间

    let athorName = "";             // 视频作者的名字
    let count_into_zb = 0;          // 进入直播间的次数
    let b_isChange = true;          // true：是刚更改模式，felse：不是刚更改模式
    let str_old_desc = "你不可能是我这个内容895470";    // 作品的内容 id = "com.ss.android.ugc.aweme:id/desc" className = "android.widget.TextView" clickable = true  text里是作品的描述

    while (EnumSlfConf.b_isCanRunningScript) {
        console.log("模式为：", model_now);

        if (b_isChange && (new Date() - t_start > script_long_time)) {
            console.log("运行时间已经超过了60分钟，那就重启一下抖音吧。");
            BSCRIPT.CloseAppByRecents();
            sleep(3*1000);
            t_start = new Date();
            continue;
        }

        let page_no = S_GETINFO.CheckPage(new Date());
        if (page_no == -9) {
            console.log(new Date().Format('hh:mm:ss -> ') + "操作：打开抖音App");
            OpenDy();
            sleep_s(10);
            continue;
        }

        // 判断要执行去哪刷视频
        switch (model_now) {
            case 1: {
                if (new Date() - t_model_start > t_in_tj) {
                    console.log("超时退出刷 推荐 模式，随机更换模式");
                    t_model_start = new Date();
                    model_now = NextModel(model_now, 4, model_old);
                    model_old = 1;
                    b_isChange = true;
                    t_in_tj = random(EnumSysConf.t_in_tj_min, EnumSysConf.t_in_tj_max);
                    continue;
                }
/**
 * 判断是哪个界面。如果是推荐页的话就继续执行。如果不是推荐页的话就去推荐页。
 * 判读是不是关注的人，如果是关注的人停留的时间就长一点。如果不是关注的人就随机时间。
 */
                let retName = '';
                if (page_no == -1) {
                    ClickIndexSY();            
                    sleep_s(8);
                    retName = S_GETINFO.GetAthorName(EnumSysConf.win_w, EnumSysConf.win_h, "");
                } else if (page_no == 1000) {
                    ClickIndexTJ();
                    sleep_s(8);
                    retName = S_GETINFO.GetAthorName(EnumSysConf.win_w, EnumSysConf.win_h, "");
                } else if (page_no == 1001) {
                    do {
                        NextLive(EnumSysConf.win_w, EnumSysConf.win_h);
                        sleep_s(3);
                        retName = S_GETINFO.GetAthorName(EnumSysConf.win_w, EnumSysConf.win_h, "");
                    } while (retName == athorName && EnumSlfConf.b_isCanRunningScript);
                } else {
                    console.log("刷推荐，不是想要的界面，点击返回");
                    back();
                    sleep_s(3);
                    continue;
                }
                athorName = retName;
                b_isChange = false;

                if (EnumSysConf.super_man_name != "" && retName && athorName.search(EnumSysConf.super_man_name)!= -1) {
                    console.log(new Date().Format('hh:mm:ss -> ') + '是关注的人');
                    sleep_s(random(120, 240));
                }else{
                    sleep_s(random(10, 60));
                } 
                break;
            }

            case 2: {
                if (new Date() - t_model_start > t_in_gz) {
                    console.log("超时退出刷 关注 模式，随机更换模式");
                    t_model_start = new Date();
                    model_now = NextModel(model_now, 4, model_old);
                    model_old = 2;
                    b_isChange = true;
                    t_in_gz = random(EnumSysConf.t_in_gz_min, EnumSysConf.t_in_gz_max);
                    continue;
                }

                let retName = '';
                if (page_no == -1) {
                    ClickIndexSY();            
                    sleep_s(8);
                    continue;
                } else if (page_no == 1001 || page_no == 1000) {
                    ClickIndexGZ();
                    sleep_s(3);
                    // 如果有直播条就向上一下。
                    if (selector().text("直播中").boundsInside(0,222,1080,614).exists() || selector().text("常看的人").boundsInside(0,222,1080,614).exists()) {
                        NextLive(EnumSysConf.win_w, EnumSysConf.win_h);
                        sleep_s(3);                        
                    }
                    retName = S_GETINFO.GetAthorName(EnumSysConf.win_w, EnumSysConf.win_h, "");
                } else if (page_no == 1002) {
                    if (b_isChange) {
                        str_old_desc = "你不可能是我这个内容895470";
                    }
                    let str_desc = "";
                    b_isChange = false;
                    var int_count = 0;      // 循环的次数
                    do {
                        int_count = int_count + 1;
                        if (int_count > 3) {
                            console.log("超过了3次，说明没有新的关注内容了。");
                            t_model_start = new Date();
                            model_now = NextModel(model_now, 4, model_old);
                            model_old = 3;
                            b_isChange = true;
                            t_in_gz = random(EnumSysConf.t_in_gz_min, EnumSysConf.t_in_gz_max);
                        }
                        NextLive(EnumSysConf.win_w, EnumSysConf.win_h);
                        sleep_s(3);
                        let desc_tmp = selector().id("com.ss.android.ugc.aweme:id/desc").className("android.widget.TextView").clickable(true);
                        if (desc_tmp.exists()) {
                            str_desc = desc_tmp.findOnce(5000).text();
                        } else {
                            console.log("没有找到作品的desc，这是不正常的，退出这次操作");
                            break;
                        }
                    } while (str_desc == str_old_desc && EnumSlfConf.b_isCanRunningScript);

                    if (int_count > 3) {
                        continue;
                    }

                    str_old_desc = str_desc;
                } else {
                    console.log("刷关注，不是想要的界面，点击返回");
                    back();
                    sleep_s(3);
                    continue;
                }
                athorName = retName;

                if (EnumSysConf.super_man_name != "" &&  retName && athorName.search(EnumSysConf.super_man_name)!= -1) {
                    console.log(new Date().Format('hh:mm:ss -> ') + '是关注的人');
                    sleep_s(random(120, 240));
                }else{
                    sleep_s(random(10, 60));
                } 
                break;
            }

            case 3: {
                let retName = '';
                if (page_no == -1) {
                    ClickIndexSY();            
                    sleep_s(8);
                    retName = S_GETINFO.GetAthorName(EnumSysConf.win_w, EnumSysConf.win_h, "");
                } else if (page_no == 1000) {
                    ClickIndexTJ();
                    sleep_s(8);
                    retName = S_GETINFO.GetAthorName(EnumSysConf.win_w, EnumSysConf.win_h, "");
                } else if (page_no == 6) {
                    back();
                    sleep_s(3);
                    continue;
                } else if (page_no == 5) {
                    console.log("直播间里等待：", t_in_zb);
                    sleep_s(t_in_zb);
                    // sleep_s( random(3, 30)*60);
                    console.log("超时退出刷 直播间 模式，随机更换模式");
                    t_model_start = new Date();
                    model_now = NextModel(model_now, 4, model_old);
                    model_old = 3;
                    b_isChange = true;
                    t_in_zb = random(EnumSysConf.t_in_zb_min, EnumSysConf.t_in_zb_max)/1000;
                    continue;
                } else if (selector().text("点击进入直播间").boundsInside(EnumSysConf.win_w/10, EnumSysConf.win_h/4, EnumSysConf.win_w/10*9, EnumSysConf.win_h/4*3).exists()) {
                    console.log("检测到可以点进直播间");
                    if (count_into_zb > 4) {
                        console.log("进入直播间出现了问题，有可能是抖音卡住了");
                        count_into_zb = 0;
                        BSCRIPT.CloseAppByRecents();
                        sleep_s(3);
                        continue;
                    }
                    click(EnumSysConf.win_w/2, EnumSysConf.win_h/2);
                    count_into_zb = count_into_zb + 1;
                    sleep_s(8);
                    continue;
                } else if ( page_no == 1001 && page_no != 5) {
                    var int_count = 0;
                    do {
                        NextLive(EnumSysConf.win_w, EnumSysConf.win_h);
                        sleep_s(3);
                        retName = S_GETINFO.GetAthorName(EnumSysConf.win_w, EnumSysConf.win_h, "");
                    } while (retName == athorName && EnumSlfConf.b_isCanRunningScript);
                } else {
                    console.log("刷直播，不是想要的界面，点击返回");
                    back();
                    sleep_s(3);
                    continue;
                }

                t_model_start = new Date();
                athorName = retName;

                if (EnumSysConf.super_man_name != "" &&  retName && athorName.search(EnumSysConf.super_man_name)!= -1) {
                    console.log(new Date().Format('hh:mm:ss -> ') + '是关注的人');
                    sleep_s(random(120, 240));
                }else{
                    sleep_s(random(10, 60));
                } 
                break;
            }

            case 4: {
                // className:android.view.View
                // 视频，    点赞数
                // className("android.view.View").descMatches(/[视频，]\w*[，点赞数]/)

                if ( int_in_grzy < int_have_grzy + 1) {
                    console.log("超量退出刷 个人主页 模式，随机更换模式");
                    t_model_start = new Date();
                    model_now = NextModel(model_now, 4, model_old);
                    model_old = 4;
                    b_isChange = true;
                    int_have_grzy = 0;
                    int_in_grzy = random(EnumSysConf.int_in_grzy_min, EnumSysConf.int_in_grzy_max);
                    continue;
                }

                let retName = '';
                if (page_no == -1) {
                    ClickIndexSY();            
                    sleep_s(8);
                    retName = S_GETINFO.GetAthorName(EnumSysConf.win_w, EnumSysConf.win_h, "");
                }else if (page_no == 2001) {
                    // TODO：点击作品按钮
                    // className = "android.widget.TextView" desc = "作品" + 数量 text = "作品" + 数量 父节点的父节点可以点击
                    // 如果父节点的父节点有兄弟节点的话就点击，这个还没有做
                    var str_zp = selector().className("android.widget.TextView").descStartsWith("作品").textStartsWith("作品");
                    if (str_zp.exists()) {
                        str_zp.findOnce(5000).parent().parent().click();
                        console.log("点击作品按钮");
                        sleep_s(1);
                    } else {
                        back();
                        sleep_s(3);
                        NextLive(EnumSysConf.win_w, EnumSysConf.win_h);
                        sleep_s(3);
                        continue;
                    }
                    // 如果没有作品就返回，并重新进入视频
                    if (selector().text("还没有作品").exists()) {
                        back();
                        sleep_s(10);
                        NextLive(EnumSysConf.win_w, EnumSysConf.win_h);
                        sleep_s(5);
                        continue;
                    }

                    // 查找视频，然后点击进入
                    while (!selector().className("android.view.View").descStartsWith("视频，").exists()) {
                        NextLive(EnumSysConf.win_w, EnumSysConf.win_h);
                        sleep_s(3);
                    }

                    // 检查是否进入视频，获取视频人物的名字
                    let zp_bound = selector().className("android.view.View").descStartsWith("视频，").findOnce();

                    console.log(zp_bound.click());

                    sleep_s(random(10, 40*1.5));
                    int_have_grzy = int_have_grzy + 1;
                } else if (page_no == 2002) {
                    NextLive(EnumSysConf.win_w, EnumSysConf.win_h);
                    sleep_s(random(10, 60*1.5));
                    int_have_grzy = int_have_grzy + 1;
                } else if (page_no == 1001) {
                    name_grzy = S_GETINFO.GetAthorName(EnumSysConf.win_w, EnumSysConf.win_h, "");

                    // 进入个人的主页
                    InToAthorPage(EnumSysConf.win_w, EnumSysConf.win_h);

                    sleep_s(3);
                } else if (page_no == 1000) {
                    ClickIndexTJ();
                    sleep_s(8);
                } else {
                    console.log("在个人主页出现问题了，修改一下吧。");
                    back();
                    sleep_s(2);
                }
                break;
            }

            case 5: {

                break;
            }

                
            default:
                break;
        }

        // 如果是第一次运行这个函数，那么就运行刷推荐视频

    }
    EnumSlfConf.b_isCanRunningScript = false;

    BSCRIPT.CloseAppByRecents();
}

/**
 * 通过关注页面进入想要进入的直播间
 */
function IntoSuperRoomByCare() {
    LoadAllVariable();
    SetState("开始进直播间脚本");

/**
 * 2刷视频-刷视频的时长随机，可以在3秒到1分半之间随机需要在推荐页和关注页切换刷 《比如刷十几分钟推荐页在刷十几分钟的关注页，切换的时间不要固定，设定5分钟到20分钟随机》
 * 3 随机进入主页刷视频，随机刷1-6个视频之后，退出2次 回到抖音主页然后继续重复步骤2和步骤3 《随机进入一个人的主页刷1-6个随机视频之后返回主页，间隔5-20分钟之间随机进入下一个人的主页》
 * 4 在刷推荐页和关注页的时候 如果刷到直播间可以随机进入直播间观看直播观看时长随机3-30分钟之间。
 * 5 保留之前刷到指定作者之后观看视频时长2分钟-4分钟随机。
 */
    EnumSlfConf.b_isCanRunningScript = true;

    let t_in_zb = random(EnumSysConf.t_in_care_room_min, EnumSysConf.t_in_care_room_max);        // 准备转入到直播界面的时间

    let t_model_start = new Date();       // 开始运行的时间
    let t_start = new Date();

    let athorName = "";             // 视频作者的名字
    let scriptState = 1;            // 当前脚本的模式，1：找直接间进入，2：退出当前直播间回到推荐页，3：是自己选择的直播间
    let inroom_long_time = 1000*60*60;  // 直播间脚本的超时时间
    while (EnumSlfConf.b_isCanRunningScript) {
        if ((scriptState != 3) && (new Date() - t_start > inroom_long_time)) {
            console.log("运行时间已经超过了60分钟，那就重启一下抖音吧。");
            BSCRIPT.CloseAppByRecents();
            sleep(3*1000);
            t_start = new Date();
            continue;
        }

        let page_no = S_GETINFO.CheckPage(new Date());
        let retName = '';
        if (page_no == -9) {
            console.log(new Date().Format('hh:mm:ss -> ') + "操作：打开抖音App");
            OpenDy();
            sleep_s(10);
            t_start = new Date();
            continue;
        } else if (page_no == -1) {
            ClickIndexSY();
            sleep_s(8);
            continue;
        } else if (scriptState == 1) {
            // 这里的主要掕是进入关注页，和向上滑动关注页的作品
            if ((page_no == 1001 || page_no == 1000 )) {
                ClickIndexGZ();
                sleep_s(3);
                // ClickIndexGZ();
                // sleep_s(2);
                continue;
            } else if (page_no == 1002) {
                // 点击个直播按钮  desc = "个直播按钮"  text = "个直播"  ，父节点可以点击
                // 下拉后可以找到可以点击的直播中按钮   desc = 作者名 + "直播中" , className = "android.widget.Button" 可以点击 bounds(18,222,264,614)
                // 那一条的id 是 ： recycler_view  bounds ( 0,222,1080,614)
                // 滑动找关注的人区间为：(0,222,756,614)

                /**
                 * 1、查看当前的界面有没有 text = "常看的人" 或者 text = "直播中"  范围( 0,222,1080,614)
                 * 2、如果有1则在1的范围内查看有没有想要进入的直播间，如果没有的话，就在1~3的位置内滑动，一直到能找到想要的人。
                 * 3、如果没有没有1的条件则想找  desc = "个直播按钮"  text = "个直播"  ，父节点可以点击，等待出现1的条件。
                 */

                if (selector().text("直播中").boundsInside(0,222,1080,614).exists() || selector().text("常看的人").boundsInside(0,222,1080,614).exists()) {
                    console.log("在关注页显示快速直播按钮或常看的人");
                    var b_isFind = false;
                    var find_name = "";
                    var find_old_name = "";
                    var btn_findOne = selector().className("android.widget.Button").clickable(false).descEndsWith("直播中").boundsInside(0,222,1080,614);
                    if (btn_findOne.exists()) {
                        find_name = btn_findOne.findOne(5000).text();
                        console.log("作者名：" + find_name);
                    }
                    while (find_old_name != find_name) {
                        find_old_name = find_name;
                        var btn_intoRoom = selector().className("android.widget.Button").clickable(true).desc(EnumSysConf.super_man_name_into_room + "直播中").boundsInside(0,222,1080,614);
                        if (btn_intoRoom.exists()) {
                            btn_intoRoom.findOne(5000).click();
                            sleep_s(4);
                            b_isFind = true;
                            t_model_start = new Date();
                            scriptState = 3;
                            break;
                        } else {
                            console.log("没有到特定的人");
                        }

                        BSCRIPT.swipe_s((627) + random(3, 8), (418) + random(3, 8), (123) + random(3, 8), (418) + random(3, 8), random(300, 500));

                        console.log("向左滑动");

                        btn_findOne = selector().className("android.widget.Button").clickable(false).descEndsWith("直播中").boundsInside(0,222,1080,614);
                        if (btn_findOne.exists()) {
                            find_name = btn_findOne.findOne(5000).text();
                            console.log("2作者名：" + find_name);
                        } else {
                            console.log("没有找到直播的人");
                        }
                    }

                    if (b_isFind) {
                        console.log("找到了想要找的作者");
                        continue;
                    } else {
                        console.log("没有找到想要找的作者");
                    }

                } else {
                    var btn = selector().descEndsWith("个直播按钮").textEndsWith("个直播").boundsInside(0,222,1080,614);
                    if (btn.exists()) {
                        btn.findOne(5000).parent().click();
                        sleep_s(3);
                        continue;
                    }
                }

                NextLive(EnumSysConf.win_w, EnumSysConf.win_h);
            } else {
                console.log("不知道是哪个界面，点击返回");
                back();
                sleep_s(3);
                continue;  
            }
            sleep_s(3);
            retName = S_GETINFO.GetAthorName(EnumSysConf.win_w, EnumSysConf.win_h, "");
        } else if (scriptState == 2) {
            // 如果不是推荐页的话就返回到推荐页去。
            if (page_no == 1002 || page_no == 1000) {
                console.log("不进入直播间，点击进入推荐界面");
                ClickIndexTJ();            
                sleep_s(3);
                // ClickIndexTJ();
                // sleep_s(10);
                continue;
            } else if ((page_no != 1001)) {
                console.log("退出当前界面，点击返回");
                back();
                sleep_s(3);
                continue;  
            } else if (page_no == 1001) {
                console.log("已重新返回推荐界面");
                scriptState = 1;
                continue;
            }
        } else if (scriptState == 3) {
            if ((page_no != 5) || (new Date() - t_model_start > t_in_zb)) {
                if (page_no == 1002 && (new Date() - t_model_start < t_in_zb)) {
                    BSCRIPT.CloseAppByRecents();
                    sleep_s(3);
                }
                console.log("当前界面：" + page_no);
                console.log("不在直播界面或者超时退出刷当前直播间并重新进入");
                t_in_zb = random(EnumSysConf.t_in_care_room_min, EnumSysConf.t_in_care_room_max);
                scriptState = 2;
                continue;
            } else if (page_no == 5){
                console.log("获取当前的作者名，如果不是自己的作者就退出");
                var get_now_name = GetLiveRoomAthorName();
                console.log("当前的作者名：" + get_now_name);
                if (get_now_name.search(EnumSysConf.super_man_name_into_room) == -1) {
                    console.log("不是想要在的直播间，退出重新找直播间");
                    t_in_zb = random(EnumSysConf.t_in_care_room_min, EnumSysConf.t_in_care_room_max);
                    scriptState = 2;   
                }
            }
            sleep_s(5);
            continue;
        }
        // athorName = retName;

        // if (EnumSysConf.super_man_name != "" &&  retName && athorName.search(EnumSysConf.super_man_name_into_room)!= -1) {
        //     console.log(new Date().Format('hh:mm:ss -> ') + '是关注的人');

        //     while (selector().text("点击进入直播间").boundsInside(EnumSysConf.win_w/10, EnumSysConf.win_h/4, EnumSysConf.win_w/10*9, EnumSysConf.win_h/4*3).exists()) {
        //         console.log("检测到可以点进直播间");
        //         if (count_into_zb > 4) {
        //             console.log("进入直播间出现了问题，有可能是抖音卡住了");
        //             count_into_zb = 0;
        //             BSCRIPT.CloseAppByRecents();
        //             sleep_s(3);
        //             break;
        //         }
        //         click(EnumSysConf.win_w/2, EnumSysConf.win_h/2);
        //         count_into_zb = count_into_zb + 1;
        //         sleep_s(8);
        //     }
        //     t_model_start = new Date();
        //     scriptState = 3;
        // }else{
        //     sleep_s(random(5, 20));
        // } 
    }
    EnumSlfConf.b_isCanRunningScript = false;

    BSCRIPT.CloseAppByRecents();
}


function test() {

    while (selector().idStartsWith("com.ss.android.ugc.aweme:id/").exists()) {
        console.log("下一个视频");
        NextLive(EnumSysConf.win_w, EnumSysConf.win_h);

        sleep(1000 * random(10, 30));
    }
    console.log("不在抖音里");
}


module.exports = {
    NextLive : NextLive,      // 下一个视频
    ClosePage : ClosePage,      // 
    
    OpenDy : OpenDy,                // 通过伏羲X打开抖音

    // 点击
    ClickIndexSY: ClickIndexSY,
    ClickIndexTJ: ClickIndexTJ,
    ClickIndexGZ: ClickIndexGZ,

    BringUpAcc: BringUpAcc,             // 自动养号
    IntoSuperRoomByCare: IntoSuperRoomByCare,   // 通过关注页面进入想要进入的直播间

    StopAllScript: StopAllScript,       // 停止全部的脚本

    test: test,

}